pecification of dependency areas in UML designs

A concept of dependency areas can help in tracing an impact of artifacts of a project (requirements, elements of the UML design, extracts of the code) and assist in their evolution. The dependency area of an element of a UML design is a part of the design that is highly influenced by the given initial element. Dependency areas are identified using sets of propagation rules and strategies. Selection strategies control application of many, possible rules. Bounding strategies limit the number of elements assigned to the areas. This paper is devoted to the specification of the rules and strategies. They are specified using an extended UML meta-model and expressions in the Object Constraint Language (OCL)

Experiences of software engineering training

In this paper some experiences from laboratories of Advanced Software Engineering course are presented. This laboratory consists of seven exercises. The subjects of exercises are following: requirements engineering, system design with UML [1], reuse, precise modelling with the Object Constraint Language (OCL [2]), code coverage testing, memory leaks detection and improving application efficiency. For each laboratory exercise a set of training materials and instructions was developed. These internet materials are stored on a department server and are available for all students and lecturers of this course. Rational Suite tools [3] are used in the laboratory. The goal of introducing Internet materials was to improve the quality of SE education. Some experiences and observations are presented. The evaluation of students results is also given

Interpretation Problems in Code Generation from UML State Machines -a Comparative Study

Abstract. A practical utilisation of a model-driven approach to an information system development is hampered by inconsistencies causing interpretation problems. This paper focuses on the state machine that is a common means for modelling behaviour. A transformation of classes with their state machines into a code assists in the efficient development of reliable applications. A set of interpretation problems of state machines was revisited in accordance with the UML specification and examined on model examples transformed to an executable code. The paper compares the implementation of the problems regarding to two tools that support the transformation and takes into account the most comprehensive set of the UML behavioural state machine concepts. The tools are the IBM Rational Rhapsody, which transforms state machines to C, C++, Java, Ada and the Framework for eXecutable UML (FXU) dealing with the C# code. The basic information about the FXU tool is also given

An Experimental Case Study to Applying Mutation Analysis for SQL Queries

Abstract—This paper is devoted to evaluation of mutation operators of SQL queries that retrieve information from a database. The operators mimic various faults of the queries that are syntactically correct but produce results unintended by the developers. A case study applies the SQL mutation operators to typical queries commonly used in programs cooperating with a real database implemented in an insurance company. The experimental results of the mutation testing and performance measures are provided. Usability of operators was validated comparing distribution of generated mutants, ability to detect mutants by tests and execution times of mutants. I I

Object-Oriented Testing Capabilities and Performance Evaluation of the C# Mutation System

Part 3: Measurements, Testing, and Quality of SoftwareInternational audienceThe main purpose of mutation testing approach is to check a test suite quality in terms of the adequacy to killing programs with inserted programming faults. We present advances in the C# mutation testing system that supports object-oriented mutation operators. The system enhancements related to functional requirements (mutation operators, avoiding generation of invalid and partially of equivalent mutants) and non-functional ones (speed-up using a new parser and reflection, space reduction storing mutant updates). Mutation testing of six widely used open source programs is discussed. The quality of the tests supplied with these programs was experimentally determined. Performance measures were evaluated to assess system enhancements (2-4 faster mutants creation, 10-100 times disk space reduction, tradeoff of time overhead for storing mutants of different size in a local or remote repository)

Quality Evaluation of Object-Oriented and Standard Mutation Operators Applied to C# Programs

Abstract. Mutation testing is a kind of fault injection approach that can be used to generate tests or to assess the quality of test sets. For object-oriented languages, like C#, both object-oriented and standard (traditional) mutation operators should be applied. The methods that can contribute to reducing the number of applied operators and lowering the costs of mutation testing were experimentally investigated. We extended the CREAM mutation tool to support selective testing, sampling and clustering of mutants, and combining code coverage with mutation testing. We propose an approach to quality evaluation and present experimental results of mutation operators applied to C# programs

Specification of dependency areas in UML designs

A concept of dependency areas can help in tracing an impact of artifacts of a project (requirements, elements of the UML design, extracts of the code) and assist in their evolution. The dependency area of an element of a UML design is a part of the design that is highly influenced by the given initial element. Dependency areas are identified using sets of propagation rules and strategies. Selection strategies control application of many, possible rules. Bounding strategies limit the number of elements assigned to the areas. This paper is devoted to the specification of the rules and strategies. They are specified using an extended UML meta-model and expressions in the Object Constraint Language (OCL). 1